package org.apli.haiam.admin.jsf.managed;

import static com.sun.faces.facelets.util.Path.context;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.List;
import java.util.ResourceBundle;
import javax.faces.application.FacesMessage;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.ViewScoped;
import javax.faces.context.FacesContext;
import javax.faces.model.DataModel;
import javax.faces.model.SelectItem;
import org.apli.haiam.admin.entidades.UsuarioAdmin;
import org.apli.haiam.ejb.entidades.AdmDivisionPolitica;
import org.apli.haiam.ejb.entidades.AdmPermiso;
import org.apli.haiam.ejb.entidades.AdmTipoConsulta;
import org.apli.haiam.ejb.entidades.AdmUsuario;
import org.apli.haiam.ejb.entidades.CexAgenda;
import org.apli.haiam.ejb.entidades.CexConsulta;
import org.apli.haiam.ejb.entidades.CexDiagnostico;
import org.apli.haiam.ejb.entidades.CexDiagnosticoConsulta;
import org.apli.haiam.ejb.entidades.CexEspecialidad;
import org.apli.haiam.ejb.entidades.CexEspecialidadMedico;
import org.apli.haiam.ejb.entidades.CexExamenFisico;
import org.apli.haiam.ejb.entidades.CexGrupoAtencion;
import org.apli.haiam.ejb.entidades.CexHistoriaClinica;
import org.apli.haiam.ejb.entidades.CexHorario;
import org.apli.haiam.ejb.entidades.CexHorariosDia;
import org.apli.haiam.ejb.entidades.CexPreparacion;
import org.apli.haiam.ejb.entidades.CexRevisionOrganos;
import org.apli.haiam.ejb.entidades.CexTratamientoConsulta;
import org.apli.jsf.managed.JsfBean;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Clase backing Bean que administra la entidad CexConsulta.
 * <p>
 * <H6>Soporte:HAIAM
 * <I>david_s_1086@hotmail.com,david.carranza@haiam.gob.ec</I></H6>
 *
 * @author david Carranza
 * @version 1.0 30/07/2014
 */
@ManagedBean
@ViewScoped
public class JsfRedaca extends JsfBean<CexConsulta> {

    final Logger log = LoggerFactory.getLogger(JsfRedaca.class);
    private List<CexHorariosDia> listaDetalle;
    private Integer tipoBusqueda;
    private String parametroBusqueda;
    private CexEspecialidad subEspecialidad;
    private CexEspecialidadMedico cexMedico;
    private UsuarioAdmin user;
    private AdmUsuario usuario;
    private CexRevisionOrganos revisionOrganos;
    private CexDiagnosticoConsulta diagnostico1;
    private List<CexDiagnosticoConsulta> listaDiagnostico;
    private CexPreparacion preparacion;
    private CexExamenFisico examenFisico;
//////    private CexProTrat procedimiento;
//////    private List<CexProTrat> listaProcedimiento;
//////    private CexTratamientoActividades actividad1;
//////    private CexTratamientoActividades actividad2;
//////    private CexTratamientoActividades actividad3;
    private String busquedaDiagnostico;
    private int tipoBusquedaDiagnostico;
    private List<CexDiagnostico> listadiagnosticoPopup;
    private Date fechaBusqueda;
    private CexAgenda agenda;
    private Date fechaAgenda;
    private CexEspecialidad especialidad;
    private CexHorariosDia horarioDia;
    private String clave;
    private Integer numredaca;
    private List<CexConsulta> listaContador;
    private String nombre;
    private String cedula;
    private CexGrupoAtencion grupoAtencion;
    private Date fechaInicio;
    private Date fechaFin;
    private List<CexHistoriaClinica> listaHClinica;
    private String apellidoPbusqueda;
    private String apellidoMbusqueda;
    private String pnombrebusqueda;
    private String snombrePbusqueda;
    private Calendar horaInicioAm;
    private Calendar horaFinAm;
    private Calendar horaInicioPm;
    private Calendar horaFinPm;
    private CexHistoriaClinica cexHistoria;
    private boolean isPrevencion;
    private AdmTipoConsulta admTipoConsulta;
    private static final String NAME_REPORTE = "RPT_RDACAA.jasper";
    private static final String TIPO_REPORTE_PDF = "application/pdf";
    private static final String TIPO_REPORTE_EXC = "application/vnd.ms-excel";

    /**
     * Constructor por defecto.
     */
    public JsfRedaca() {
    }

    /**
     * Inicializa los datos miembros.
     */
    @Override
    protected void inicializar() {
        //setSwGrabar(false);
        object = new CexConsulta();
        listaDetalle = new ArrayList<>();
        user = (UsuarioAdmin) FacesContext.getCurrentInstance().getExternalContext().getSessionMap().get("user");
        usuario = user.getUser();
        revisionOrganos = new CexRevisionOrganos();
        preparacion = new CexPreparacion();
        examenFisico = new CexExamenFisico();
        diagnostico1 = new CexDiagnosticoConsulta();
        listaDiagnostico = new ArrayList<>();
////////////        procedimiento = new CexProTrat();
////////////        listaProcedimiento = new ArrayList<>();
////////////        actividad1 = new CexTratamientoActividades();
////////////        actividad2 = new CexTratamientoActividades();
////////////        actividad3 = new CexTratamientoActividades();
        busquedaDiagnostico = null;
        tipoBusquedaDiagnostico = 1;
        listadiagnosticoPopup = null;
        fechaBusqueda = new Date();
        agenda = new CexAgenda();
        especialidad = new CexEspecialidad();
        subEspecialidad = new CexEspecialidad();
        horarioDia = new CexHorariosDia();
        clave = new String();
        nombre = new String();
        cedula = new String();
        diagnostico1.setDicPrevencion(0);
        diagnostico1.setDicMorbilidad(0);
        grupoAtencion = new CexGrupoAtencion();
        cexMedico = new CexEspecialidadMedico();
        listaHClinica = new ArrayList<>();
        apellidoPbusqueda = "";
        apellidoMbusqueda = "";
        pnombrebusqueda = "";
        snombrePbusqueda = "";
        cexHistoria = new CexHistoriaClinica();
        horaInicioAm = new GregorianCalendar();
        horaFinAm = new GregorianCalendar();
        horaInicioPm = new GregorianCalendar();
        horaFinPm = new GregorianCalendar();
        tipoBusqueda = 1;
        parametroBusqueda = "";
        isPrevencion = true;
        //fechaInicio = new Date();
        //fechaFin = new Date();
        try {
            fechaAgenda = admin.getFechaDb();
            //Genera el rango de fechas del mes actual para sacar el total de consultas hechas en el redaca por usuario
            Calendar c13 = Calendar.getInstance();
            Calendar fecIn = Calendar.getInstance();
            fecIn.set(Calendar.YEAR, c13.get(Calendar.YEAR));
            fecIn.set(Calendar.MONTH, c13.get(Calendar.MONTH));
            fecIn.set(Calendar.DAY_OF_MONTH, 01);
            Calendar fecFi = Calendar.getInstance();
            fecFi.set(Calendar.YEAR, c13.get(Calendar.YEAR));
            fecFi.set(Calendar.MONTH, c13.get(Calendar.MONTH));
            fecFi.set(Calendar.DAY_OF_MONTH, 31);
            listaContador = admin.listarRango(CexConsulta.class, "ccoFecha", fecIn.getTime(), fecFi.getTime(), "ccoIdUsuario", user.getUser().getIdUsuario().intValue());
            numredaca = listaContador.size();
            admTipoConsulta = (AdmTipoConsulta) adminObject.buscar(AdmTipoConsulta.class, "atcId", 1);
        } catch (Exception e) {
            log.error("grabarAction() {} ", e.getMessage());
            //FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "formDatos").getClientId(), new FacesMessage(FacesMessage.SEVERITY_ERROR, e.getMessage(), e.getMessage()));
        }

        //  cargarListaPatologia();
        //hcturnoDetalle = new CexTurnosDet();
    }

    /**
     * Graba el registro asociado al objeto que se administra en la página.
     *
     * @return null, se mantiene en la página invocada.
     */
    @Override
    public String grabarAction() {
////////////////////        FacesContext context = FacesContext.getCurrentInstance();
////////////////////        try {
////////////////////            Calendar calendar = Calendar.getInstance();
////////////////////            Calendar c13 = Calendar.getInstance();
////////////////////            Calendar fecIn = Calendar.getInstance();
////////////////////            fecIn.set(Calendar.YEAR, c13.get(Calendar.YEAR));
////////////////////            fecIn.set(Calendar.MONTH, c13.get(Calendar.MONTH));
////////////////////            fecIn.set(Calendar.DAY_OF_MONTH, 01);
////////////////////            Calendar fecFi = Calendar.getInstance();
////////////////////            fecFi.set(Calendar.YEAR, c13.get(Calendar.YEAR));
////////////////////            fecFi.set(Calendar.MONTH, c13.get(Calendar.MONTH));
////////////////////            fecFi.set(Calendar.DAY_OF_MONTH, 31);
////////////////////            //calendar.setTime(admin.getFechaDb());
////////////////////            //recuperar el dia
////////////////////            if (!listaDiagnostico.isEmpty() || listaDiagnostico.size() > 0) {
////////////////////                if (!admin.existePorCampo(CexConsulta.class, "cexPreparacion.cexAgenda.ageFecha", fechaBusqueda, "cexPreparacion.cexAgenda.cexHistoriaClinica.hcHistoriaClinica", agenda.getCexHistoriaClinica().getHcHistoriaClinica())) {
////////////////////                    //modificar la agenda a un estado de atendido
////////////////////                    //agenda.setCexHorariosDia(horarioDia);
////////////////////                    agenda.setAgeEstado(3);
////////////////////                    adminObject.modificar(agenda, (UsuarioAdmin) FacesContext.getCurrentInstance().getExternalContext().getSessionMap().get("user"));
////////////////////                    //Verificar si existe una preparacion previa
////////////////////                    if (admin.existePorCampo(CexPreparacion.class, "cexAgenda", agenda)) {
////////////////////                        preparacion = (CexPreparacion) admin.buscar(CexPreparacion.class, "cexAgenda", agenda);
////////////////////                    } else {
////////////////////                        preparacion.setPrePeso(BigDecimal.ZERO);
////////////////////                        preparacion.setPreTalla(BigDecimal.ZERO);
////////////////////                        preparacion.setPreImc(BigDecimal.ZERO);
////////////////////                        preparacion.setPreFrecenciaCar(0);
////////////////////                        preparacion.setPreFrecenciaRes(0);
////////////////////                        preparacion.setCexAgenda(agenda);
////////////////////                        preparacion.setPreEstado(2);
////////////////////                        preparacion.setPreTemperatura(BigDecimal.ZERO);
////////////////////                        preparacion.setPreIdUsuario(user.getUser().getIdUsuario().intValue());
////////////////////                        preparacion.setPreFecha(admin.getFechaDb());
////////////////////                        preparacion.setPreNombreUsuario(user.getUser().getAdmEmpleado().getNombreFull());
////////////////////                        preparacion.setPreHora(admin.getFechaDb());
////////////////////                        preparacion.setPreHoraLlegada(admin.getFechaDb());
////////////////////                        preparacion.setPreFechaLlegada(admin.getFechaDb());
////////////////////                        preparacion.setPreIdUsuarioLlegada(user.getUser().getIdUsuario().intValue());
////////////////////                        preparacion.setPreNombreUsuarioLlegada(user.getUser().getAdmEmpleado().getNombreFull());
////////////////////                        adminObject.crear(preparacion, (UsuarioAdmin) FacesContext.getCurrentInstance().getExternalContext().getSessionMap().get("user"));
////////////////////
////////////////////                    }
////////////////////
////////////////////                    //Grabar consulta
////////////////////                    //Grabar diagnosticos
////////////////////                    //grabar diagnosticos
////////////////////                    object.setCexPreparacion(preparacion);
////////////////////                    object.setConIdUsuario(user.getUser().getIdUsuario().intValue());
////////////////////                    object.setConNombreUsuario(user.getUser().getAdmEmpleado().getNombreFull());
////////////////////                    object.setConFecha(calendar.getTime());
////////////////////                    object.setConHora(calendar.getTime());
////////////////////                    object.setConEstado(3);
////////////////////                    admin.crear(object, (UsuarioAdmin) FacesContext.getCurrentInstance().getExternalContext().getSessionMap().get("user"));
////////////////////                    for (CexDiagnosticoConsulta cexDiag : listaDiagnostico) {
////////////////////                        cexDiag.setCexConsulta(object);
////////////////////                        adminObject.crear(cexDiag, (UsuarioAdmin) FacesContext.getCurrentInstance().getExternalContext().getSessionMap().get("user"));
////////////////////                    }
////////////////////                    //grabar tratamientos
////////////////////                    for (CexProTrat cexPro : listaProcedimiento) {
////////////////////                        cexPro.setCexConsulta(object);
////////////////////                        adminObject.crear(cexPro, (UsuarioAdmin) FacesContext.getCurrentInstance().getExternalContext().getSessionMap().get("user"));
////////////////////                    }
////////////////////                    //Grabar actividades
////////////////////
////////////////////                    actividad1.setCexConsulta(object);
////////////////////                    adminObject.crear(actividad1, (UsuarioAdmin) FacesContext.getCurrentInstance().getExternalContext().getSessionMap().get("user"));
////////////////////                    actividad2.setCexConsulta(object);
////////////////////                    adminObject.crear(actividad2, (UsuarioAdmin) FacesContext.getCurrentInstance().getExternalContext().getSessionMap().get("user"));
////////////////////                    actividad3.setCexConsulta(object);
////////////////////                    adminObject.crear(actividad3, (UsuarioAdmin) FacesContext.getCurrentInstance().getExternalContext().getSessionMap().get("user"));
////////////////////
////////////////////                    //inicializart
////////////////////                    listaContador = admin.listarRango(CexConsulta.class, "conFecha", fecIn.getTime(), fecFi.getTime(), "conIdUsuario", user.getUser().getIdUsuario().intValue());
////////////////////                    numredaca = listaContador.size();
////////////////////                    agenda = new CexAgenda();
////////////////////                    listaDiagnostico = new ArrayList<>();
////////////////////                    listaProcedimiento = new ArrayList<>();
////////////////////                    object = new CexConsulta();
////////////////////                    actividad1 = new CexTratamientoActividades();
////////////////////                    actividad2 = new CexTratamientoActividades();
////////////////////                    actividad3 = new CexTratamientoActividades();
////////////////////                    diagnostico1.setDicMorbilidad(0);
////////////////////                    diagnostico1.setDicPrevencion(0);
////////////////////                    listarTurnos();
////////////////////
////////////////////                    FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "formDatos").getClientId(), new FacesMessage(bundle.getString("msg.grabar")));
////////////////////                } else {
////////////////////                    FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "formDatos").getClientId(), new FacesMessage(FacesMessage.SEVERITY_ERROR, "Paciente ya se encuentra agregado", "Paciente ya se encuentra agregado"));
////////////////////                }
////////////////////            } else {
////////////////////                FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "formDatos").getClientId(), new FacesMessage(FacesMessage.SEVERITY_ERROR, "Debe agregar por lo menos 1 diagnostico", "Debe agregar por lo menos 1 diagnostico"));
////////////////////            }
////////////////////        } catch (Exception e) {
////////////////////            log.error("grabarAction() {} ", e.getMessage());
////////////////////            FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "formDatos").getClientId(), new FacesMessage(FacesMessage.SEVERITY_ERROR, e.getMessage(), e.getMessage()));
////////////////////        }

        // cargarLista();
        return null;
    }

    /**
     * Carga la lista de objetos de tipo patologia en una lista de la página.
     */
    public void buscarDiagnostico() {
        String nombreMetodo = Thread.currentThread().getStackTrace()[1].getMethodName() + "()";
        FacesContext context = FacesContext.getCurrentInstance();
        if (admin == null) {
            listadiagnosticoPopup = null;
            return;
        }
        try {
            busquedaDiagnostico = busquedaDiagnostico.toUpperCase().trim();
            if (!busquedaDiagnostico.isEmpty() || !"".equals(busquedaDiagnostico)) {
                if (tipoBusquedaDiagnostico == 1) {
                    listadiagnosticoPopup = adminObject.listarContiene(CexDiagnostico.class, "diaCodigo", busquedaDiagnostico);
                } else {
                    listadiagnosticoPopup = adminObject.listarContiene(CexDiagnostico.class, "diaNombre", busquedaDiagnostico);
                }
            }

        } catch (Exception e) {
            log.error("{}: {} ", nombreMetodo, e);
        }
    }

    /**
     * Agrega el item seleccinado de la tabla de busqueda de diagnostico al
     * objeto actual.
     *
     * @param item
     */
    public void agregarDiagnostico(CexDiagnostico item) {
////////////////        String nombreMetodo = Thread.currentThread().getStackTrace()[1].getMethodName() + "()";
////////////////        FacesContext context = FacesContext.getCurrentInstance();
////////////////        try {
////////////////            if (item.getCexDiagnostico() != null || (item.getCexDiagnostico() == null && item.getCexDiagnosticoList().isEmpty())) {
////////////////                diagnostico1.setCexDiagnostico(item);
////////////////                diagnostico1.setDicPrevencion(0);
////////////////                diagnostico1.setDicMorbilidad(0);
////////////////                diagnostico1.setCexCondicionDiagnostico(null);
////////////////                isPrevencion = diagnostico1.getCexDiagnostico().getDiaCodigo().substring(0, 1).equals("Z");
////////////////            } else {
////////////////                diagnostico1.setCexDiagnostico(null);
////////////////                diagnostico1.setDicPrevencion(0);
////////////////                diagnostico1.setDicMorbilidad(0);
////////////////                diagnostico1.setCexCondicionDiagnostico(null);
////////////////                FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "formDatos").getClientId(), new FacesMessage(FacesMessage.SEVERITY_ERROR, "No se puede agregar una categoria elija unicamente subcategorias", "No se puede agregar una categoria elija unicamente subcategorias"));
////////////////            }
////////////////        } catch (Exception e) {
////////////////            log.error("{}: {} ", nombreMetodo, e);
////////////////        }
    }

    /**
     * Obtiene una lista de objetos de tipo SelectedItem.
     *
     * @return la lista
     */
    public List<SelectItem> getSelectedItemSubespecialidad() {
        String nombreMetodo = Thread.currentThread().getStackTrace()[1].getMethodName() + "()";
        try {
            //listaAgenda = new ArrayList<CexTurnosDet>();
            //detalle.setCexMedico(null);
            List<CexEspecialidad> subespecialidad = adminObject.listarOrdenada(CexEspecialidad.class, "cexEspecialidad", especialidad, "cesEstado", 1, "cesNombre", true);
            List<SelectItem> items = new ArrayList<>();
            for (CexEspecialidad obj : subespecialidad) {
                items.add(new SelectItem(obj, obj.getCesNombre()));
            }
            return items;
        } catch (Exception e) {
            log.error("{}: {} ", nombreMetodo, e);
        }
        return null;
    }

    public List<SelectItem> getSelectedItemMedicoTurno() {
        String nombreMetodo = Thread.currentThread().getStackTrace()[1].getMethodName() + "()";
        try {
            Calendar c1 = Calendar.getInstance();
            c1.setTime(fechaBusqueda);
            int dia = c1.get(Calendar.DAY_OF_WEEK);
            List<CexEspecialidadMedico> listEspMed = new ArrayList<>();
            // lista los horarios pertenecientes al emdico de acuerdo a la especialidad
            List<CexHorario> listaHorario1 = adminObject.listarOrdenada(CexHorario.class, "cexEspecialidadMedico.cexEspecialidad", subEspecialidad, "admTipoConsulta", admTipoConsulta, "choId", true);
            // Filtra los horarios segun el dia actual
            List<SelectItem> items = new ArrayList<>();
            for (CexHorario cexHorario : listaHorario1) {
                for (CexHorariosDia cexHorarioDia1 : cexHorario.getCexHorariosDiaList()) {
                    //Validar que sea el dia actual
                    if (cexHorarioDia1.getCexDia().getCdiId().equals(dia)) {
                        if (cexHorarioDia1.getChdHoraInicioAm() != null || cexHorarioDia1.getChdHoraFinAm() != null) {
                            if (cexHorarioDia1.getCexHorario().getCexEspecialidadMedico().getAdmMedico().getAmeEstado() == 1) {
                                if (!listEspMed.contains(cexHorarioDia1.getCexHorario().getCexEspecialidadMedico())) {
                                    items.add(new SelectItem(cexHorarioDia1.getCexHorario().getCexEspecialidadMedico(), cexHorarioDia1.getCexHorario().getCexEspecialidadMedico().getAdmMedico().getAmeNombreFull()));
                                    listEspMed.add(cexHorarioDia1.getCexHorario().getCexEspecialidadMedico());
                                }
                            }
                        }
                    }
                }
            }
            return items;
        } catch (Exception e) {
            log.error("{}: {} ", nombreMetodo, e);
        }
        return null;
    }

    /**
     * Agregar items de fisico en la consulta medica.
     *
     */
    public void agregarProcedimiento() {
////////////////        String nombreMetodo = Thread.currentThread().getStackTrace()[1].getMethodName() + "()";
////////////////        FacesContext context = FacesContext.getCurrentInstance();
////////////////        try {
////////////////            int aux = 0;
////////////////            if (procedimiento.getCexProcedimiento() != null) {
////////////////                procedimiento.setPrtObservacion(procedimiento.getPrtObservacion().toUpperCase());
////////////////                for (CexProTrat cexPat : listaProcedimiento) {
////////////////                    if (cexPat.getCexProcedimiento().getProId() == procedimiento.getCexProcedimiento().getProId()) {
////////////////                        aux = 1;
////////////////                        FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "procedimientocmb").getClientId(), new FacesMessage(FacesMessage.SEVERITY_ERROR, "Tratamiento ya se encuentra agregada", "Tratamiento ya se encuentra agregada"));
////////////////                    }
////////////////                }
////////////////                if (listaProcedimiento.size() > 0) {
////////////////                    if (aux == 0) {
////////////////                        listaProcedimiento.add(procedimiento);
////////////////                        //personalPat.setCexPatologia(new CexPatologia());
////////////////                        //personalPat.setPapObservacion("");
////////////////                        procedimiento = new CexProTrat();
////////////////                    }
////////////////                } else {
////////////////                    listaProcedimiento.add(procedimiento);
////////////////                    procedimiento = new CexProTrat();
////////////////                }
////////////////            } else {
////////////////                FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "procedimientocmb").getClientId(), new FacesMessage(FacesMessage.SEVERITY_ERROR, "Tratamiento campo requerido", "Tratamiento campo requerido"));
////////////////            }
////////////////
////////////////        } catch (Exception e) {
////////////////            log.error("{}: {} ", nombreMetodo, e.getMessage());
////////////////        }

    }

    /**
     * Implementa el comportamiento para seleccionar un elemento en una lista de
     * la página.
     *
     * @param item
     * @return null, se mantiene en la página invocada.
     */
    public String seleccionarActionPreparacion(CexAgenda item) {
        FacesContext context = FacesContext.getCurrentInstance();
        //inicializar();

        try {
            if (item.getCexHistoriaClinica() != null) {
                agenda = item;
            } else {
                FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "formDatos").getClientId(), new FacesMessage(FacesMessage.SEVERITY_ERROR, "Historia clinica no existe", "Historia clinica no existe"));
            }

            //cargarListaPatologia();
        } catch (Exception e) {
            log.error("seleccionarActionPreparacion() {} ", e.getMessage());
        }
        return null;
    }

    /**
     * Inicializa el medico cada ver que se elija una nueva fecha .
     */
    public void inicializarMedico() {
        cexMedico = new CexEspecialidadMedico();

    }

    /**
     * Carga la lista de objetos en una lista de la página.
     */
    public void listarTurnos() {
        String nombreMetodo = Thread.currentThread().getStackTrace()[1].getMethodName() + "()";
        FacesContext context = FacesContext.getCurrentInstance();
        int contHor = 0;
        Calendar c1 = Calendar.getInstance();
        Integer dia = 0;
        c1.setTime(fechaBusqueda);
        dia = c1.get(Calendar.DAY_OF_WEEK);
        listaDetalle.clear();

        try {

            //Recupera permiso para saber si se puede agendar en la fecha seleccionada
            List<AdmPermiso> objLicencia = (List<AdmPermiso>) adminObject.queryEJB("select p from AdmPermiso p where :var1 between p.apeFechaInicio and p.apeFechaFin and p.admMedico = :var2", fechaBusqueda, cexMedico.getAdmMedico());
            //List<CexPermiso> objLicencia = adminObject.ejecutarQueryNativoLista("SELECT * FROM cex_Permiso where med_id = " + object.getCexHorario().getCexEspecialidadMedico().getCexMedico().getMedId() + " and date('" + fecha + "') between per_fecha_inicio and per_fecha_fin;", CexPermiso.class);
            //Verifica si tiene permiso
            if (objLicencia.size() < 0 || objLicencia.isEmpty()) {
                //Recuper la lista del horario de acuerdo al dia seleciconado
                for (CexHorario objTemH : cexMedico.getCexHorarioList()) {
                    //Verificar los horarios segun el tipo de consulta de la agenda
                    if (objTemH.getAdmTipoConsulta().equals(admTipoConsulta)) {
                        //Recorrer los horarios dias de cada horario
                        for (CexHorariosDia objTemHd : objTemH.getCexHorariosDiaList()) {
                            if (objTemHd.getCexDia().getCdiId().equals(dia)) {
                                //Añadir solo el horario que tenga asignado hora inicio y hora fin
                                if (objTemHd.getChdHoraInicioAm() != null && objTemHd.getChdHoraFinAm() != null) {
                                    listaDetalle.add(objTemHd);
                                }
                            }
                        }
                    }
                }

                //Recuperar las agendas de acuerdo al horarioDia y de acuerdo a las fechas
                for (CexHorariosDia objHorDia : listaDetalle) {
                    //Asigna el numero de horario 
                    objHorDia.setOrdenHorario(contHor);
                    objHorDia.getCexAgendaList().clear();
                    objHorDia.setCexAgendaList(adminObject.listarOrdenada(CexAgenda.class, "cexHorariosDia", objHorDia, "cagFecha", fechaBusqueda, "cagEstado", 1, "cagSecuencia", false));
                    contHor++;
                }

                //Verificar porcentages
                ///////////listarturnosTarde();
            } else {
                AdmPermiso permiso = objLicencia.get(0);
                FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "formDatos").getClientId(), new FacesMessage(FacesMessage.SEVERITY_ERROR, "Agenda no disponible", "Médico no disponible en la fecha ha seleccioanda por motico de " + permiso.getApeMotivo() + ""));
            }

        } catch (Exception e) {
            log.error("{}: {} ", nombreMetodo, e);
        }
    }

    /**
     * Obtiene una lista de objetos de tipo SelectedItem.
     *
     * @return la lista
     */
    @Override
    public List<SelectItem> getSelectedItem() {
        try {
            List<CexConsulta> datos = admin.listarOrdenada(object.getClass(), "nombre", true);
            List<SelectItem> items = new ArrayList<>();
            for (CexConsulta obj : datos) {
                //     items.add(new SelectItem(obj.getIdHistoriaLaboral()));
            }
            return items;
        } catch (Exception e) {
            log.error("getSelectedItem() {} ", e.getMessage());
        }
        return null;
    }

    /**
     * Agregar items de las patologias en antecedentes personaes.
     *
     */
    public void agregarDiagnostico() {
////////////////        String nombreMetodo = Thread.currentThread().getStackTrace()[1].getMethodName() + "()";
////////////////        FacesContext context = FacesContext.getCurrentInstance();
////////////////        try {
////////////////            int aux = 0;
////////////////            if (listaDiagnostico.size() >= 0 && listaDiagnostico.size() <= 2) {
////////////////
////////////////                if (isPrevencion) {
////////////////                    if (diagnostico1.getDicPrevencion() == 0) {
////////////////                        FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "formDatos").getClientId(), new FacesMessage(FacesMessage.SEVERITY_ERROR, "Prevención campo obligatorio", "Prevención campo obligatorio"));
////////////////                        return;
////////////////                    }
////////////////                } else {
////////////////                    if (diagnostico1.getDicMorbilidad() == 0 || diagnostico1.getCexCondicionDiagnostico() == null) {
////////////////                        FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "formDatos").getClientId(), new FacesMessage(FacesMessage.SEVERITY_ERROR, "Morbilidad y tipo de diagnostico campo obligatorio", "Morbilidad y tipo de diagnostico campo obligatorio"));
////////////////                        return;
////////////////                    }
////////////////                }
////////////////
////////////////                if (diagnostico1.getCexDiagnostico() != null) {
////////////////                    diagnostico1.setDicDiagnostico(diagnostico1.getDicDiagnostico().toUpperCase());
////////////////                    for (CexDiagnosticoConsulta cexPat : listaDiagnostico) {
////////////////                        if (cexPat.getCexDiagnostico().getDiaId() == diagnostico1.getCexDiagnostico().getDiaId()) {
////////////////                            aux = 1;
////////////////                            FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "diag1").getClientId(), new FacesMessage(FacesMessage.SEVERITY_ERROR, "Diagnostico ya se encuentra agregado", "Diagnostico ya se encuentra agregado"));
////////////////                        }
////////////////                    }
////////////////                    if (listaDiagnostico.size() > 0) {
////////////////                        if (aux == 0) {
////////////////                            listaDiagnostico.add(diagnostico1);
////////////////                            //personalPat.setCexPatologia(new CexPatologia());
////////////////                            //personalPat.setPapObservacion("");
////////////////                            diagnostico1 = new CexDiagnosticoConsulta();
////////////////                            diagnostico1.setDicMorbilidad(0);
////////////////                            diagnostico1.setDicPrevencion(0);
////////////////                        }
////////////////                    } else {
////////////////                        listaDiagnostico.add(diagnostico1);
////////////////                        diagnostico1 = new CexDiagnosticoConsulta();
////////////////                        diagnostico1.setDicMorbilidad(0);
////////////////                        diagnostico1.setDicPrevencion(0);
////////////////                    }
////////////////                } else {
////////////////                    FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "diag1").getClientId(), new FacesMessage(FacesMessage.SEVERITY_ERROR, "Diagnostico campo requerido", "Diagnostico campo requerido"));
////////////////                }
////////////////
////////////////            } else {
////////////////                FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "diag1").getClientId(), new FacesMessage(FacesMessage.SEVERITY_ERROR, "Solo permitido 3 diagnostico", "Solo permitido 3 diagnostico"));
////////////////            }
////////////////        } catch (Exception e) {
////////////////            log.error("{}: {} ", nombreMetodo, e.getMessage());
////////////////        }

    }

    /**
     * Seleccuina diagnostico y elimina diagnostico consulta.
     *
     * @param item
     */
    public void eliminarDiagnostico(CexDiagnosticoConsulta item) {
////////////////        String nombreMetodo = Thread.currentThread().getStackTrace()[1].getMethodName() + "()";
////////////////        try {
////////////////            List<CexDiagnosticoConsulta> lisTe = new ArrayList<>();
////////////////            for (CexDiagnosticoConsulta cexCon : listaDiagnostico) {
////////////////                if (!item.getCexDiagnostico().getDiaId().equals(cexCon.getCexDiagnostico().getDiaId())) {
////////////////                    lisTe.add(cexCon);
////////////////                }
////////////////            }
////////////////            listaDiagnostico.clear();
////////////////            listaDiagnostico = lisTe;
////////////////        } catch (Exception e) {
////////////////            log.error("{}: {} ", nombreMetodo, e.getMessage());
////////////////        }

    }

    /**
     * Seleccuina procedimiento y elimina de la consulta.
     *
     * @param item
     */
    public void eliminarProcedimiento(CexTratamientoConsulta item) {
//////////        String nombreMetodo = Thread.currentThread().getStackTrace()[1].getMethodName() + "()";
//////////        try {
//////////            List<CexProTrat> lisTe = new ArrayList<>();
//////////            for (CexProTrat cexCon : listaProcedimiento) {
//////////                if (!item.getCexProcedimiento().getProId().equals(cexCon.getCexProcedimiento().getProId())) {
//////////                    lisTe.add(cexCon);
//////////                }
//////////            }
//////////            listaProcedimiento.clear();
//////////            listaProcedimiento = lisTe;
//////////        } catch (Exception e) {
//////////            log.error("{}: {} ", nombreMetodo, e.getMessage());
//////////        }

    }

    /**
     * Seleccuina grupo prioritario y elimina de la consulta.
     *
     * @param item
     */
    public void eliminarGrupoPrioritario(CexGrupoAtencion item) {
//////////////        String nombreMetodo = Thread.currentThread().getStackTrace()[1].getMethodName() + "()";
//////////////        try {
//////////////            List<CexGrupoAtencion> lisTe = new ArrayList<>();
//////////////            for (CexGrupoAtencion cexCon : object.getCexGrupoAtencionList()) {
//////////////                if (!item.getGraId().equals(cexCon.getGraId())) {
//////////////                    lisTe.add(cexCon);
//////////////                }
//////////////            }
//////////////            object.getCexGrupoAtencionList().clear();
//////////////            object.setCexGrupoAtencionList(lisTe);
//////////////        } catch (Exception e) {
//////////////            log.error("{}: {} ", nombreMetodo, e.getMessage());
//////////////        }

    }

    /**
     * Agregar items de las patologias en antecedentes familiares.
     *
     */
    public void agregarPrioritario() {
        String nombreMetodo = Thread.currentThread().getStackTrace()[1].getMethodName() + "()";
        FacesContext context = FacesContext.getCurrentInstance();
        try {
            List<CexGrupoAtencion> guppoList = new ArrayList<>();
            guppoList.add(grupoAtencion);
            object.setCexGrupoAtencionList(guppoList);
////////            if (familiarPat.getCexPatologia() != null) {
////////                if (familiarPat.getCexParentesco() != null) {
////////                    familiarPat.setAnfObservacion(familiarPat.getAnfObservacion().toUpperCase());
////////                    for (CexAntecedentesFamiliares cexPat : listaPatologiaF) {
////////                        if (cexPat.getCexPatologia().getPatId() == familiarPat.getCexPatologia().getPatId()) {
////////                            aux = 1;
////////                            FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "patologiacmbfam").getClientId(), new FacesMessage(FacesMessage.SEVERITY_ERROR, "Patología ya se encuentra agregada", "Patología ya se encuentra agregada"));
////////                        }
////////                    }
////////                    if (listaPatologiaF.size() > 0) {
////////                        if (aux == 0) {
////////                            listaPatologiaF.add(familiarPat);
////////                            //personalPat.setCexPatologia(new CexPatologia());
////////                            //personalPat.setPapObservacion("");
////////                            familiarPat = new CexAntecedentesFamiliares();
////////                        }
////////                    } else {
////////                        listaPatologiaF.add(familiarPat);
////////                        familiarPat = new CexAntecedentesFamiliares();
////////                    }
////////                } else {
////////                    FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "parentesco3").getClientId(), new FacesMessage(FacesMessage.SEVERITY_ERROR, "Parentesco campo requerido", "Parentesco campo requerido"));
////////                }
////////            } else {
////////                FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "patologiacmbfam").getClientId(), new FacesMessage(FacesMessage.SEVERITY_ERROR, "Patología campo requerido", "Patología campo requerido"));
////////            }

        } catch (Exception e) {
            log.error("{}: {} ", nombreMetodo, e.getMessage());
        }

    }

    public void onEdit(CexHistoriaClinica item) {
//////////////        String nombreMetodo = Thread.currentThread().getStackTrace()[1].getMethodName() + "()";
//////////////        FacesContext context = FacesContext.getCurrentInstance();
//////////////        try {
//////////////            CexHistoriaClinica obj = item;
//////////////            obj.setHcApellidoPaterno(obj.getHcApellidoPaterno().toUpperCase());
//////////////            obj.setHcApellidoMaterno(obj.getHcApellidoMaterno().toUpperCase());
//////////////            obj.setHcPrimerNombre(obj.getHcPrimerNombre().toUpperCase());
//////////////            obj.setHcSegundoNombre(obj.getHcSegundoNombre().toUpperCase());
//////////////            obj.setHcNombreFull(obj.getHcApellidoPaterno().concat(" ").concat(obj.getHcApellidoMaterno()).concat(" ").concat(obj.getHcPrimerNombre()).concat(" ").concat(obj.getHcSegundoNombre()));
//////////////            obj.setHcBarrio(obj.getHcBarrio().toUpperCase());
//////////////            obj.setAdmDivisionPolitica(obj.getAdmDivisionPolitica());
//////////////            adminObject.modificar(obj, (UsuarioAdmin) FacesContext.getCurrentInstance().getExternalContext().getSessionMap().get("user"));
//////////////            FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "formDatos").getClientId(), new FacesMessage(FacesMessage.SEVERITY_INFO, "Historia clinica actualizada correctamente", "Historia clinica actualizada correctamente"));
//////////////        } catch (Exception e) {
//////////////            log.error("{}: {} ", nombreMetodo, e.getMessage());
//////////////        }
    }

    public void onCancel(CexHistoriaClinica item) {
//        FacesMessage msg = new FacesMessage("Car Cancelled", ((Car) event.getObject()).getModel());  
//  
//        FacesContext.getCurrentInstance().addMessage(null, msg);  
    }

    public List<SelectItem> getSelectedItemProvincia() {
//////////////        try {
//////////////            List<AdmDivisionPolitica> datos = admin.listarNullOrdenada(AdmDivisionPolitica.class, "admDivisionPolitica", "nombre", true);
//////////////            List<SelectItem> items = new ArrayList<>();
//////////////            for (AdmDivisionPolitica obj : datos) {
//////////////                items.add(new SelectItem(obj, obj.getCodigo().concat("-").concat(obj.getNombre())));
//////////////            }
//////////////            return items;
//////////////        } catch (Exception e) {
//////////////            log.error("getSelectedItemProvincia() {} ", e.getMessage());
//////////////        }
        return null;
    }

    public List<SelectItem> obtenerItemCanton(AdmDivisionPolitica provincia) {
//////////////        try {
//////////////
//////////////            List<SelectItem> items = new ArrayList<>();
//////////////            for (AdmDivisionPolitica obj : provincia.getAdmDivisionPoliticaList()) {
//////////////                items.add(new SelectItem(obj, obj.getCodigo().concat("-").concat(obj.getNombre())));
//////////////            }
//////////////            return items;
//////////////        } catch (Exception e) {
//////////////            log.error("getSelectedItemCanton() {} ", e.getMessage());
//////////////        }
        return null;
    }

    public List<SelectItem> obtenerItemParroquia(AdmDivisionPolitica canton) {
////////////////        try {
////////////////            List<SelectItem> items = new ArrayList<>();
////////////////            for (AdmDivisionPolitica obj : canton.getAdmDivisionPoliticaList()) {
////////////////                items.add(new SelectItem(obj, obj.getCodigo().concat("-").concat(obj.getNombre())));
////////////////            }
////////////////            return items;
////////////////        } catch (Exception e) {
////////////////            log.error("getSelectedItemParroquia() {} ", e.getMessage());
////////////////        }
        return null;
    }

    /**
     * Agregar items de las patologias en antecedentes familiares.
     *
     */
    public void imprimirRdacca() {
//////////////        String nombreMetodo = Thread.currentThread().getStackTrace()[1].getMethodName() + "()";
//////////////        FacesContext context = FacesContext.getCurrentInstance();
//////////////        try {
//////////////            String rpt = null;
//////////////            List<CexConsulta> listaConsulta = admin.listarRangoOrdenada(CexConsulta.class, "cexPreparacion.cexAgenda.ageFecha", fechaInicio, fechaFin, "conId", true);
//////////////
//////////////            try {
//////////////                rpt = reporte.generarReporte(listaConsulta, NAME_REPORTE, TIPO_REPORTE_EXC, "RDACCA");
//////////////            } catch (Exception e) {
//////////////                log.error("imprimirHistoriaClinica(...) " + e);
//////////////            }
//////////////        } catch (Exception e) {
//////////////            log.error("{}: {} ", nombreMetodo, e.getMessage());
//////////////        }

    }

    /**
     * Metodo que busca una historia clinica por apellidos
     *
     *
     *
     *
     * @author David Carranza
     */
    public void buscarApellidos() {
        String nombreMetodo = Thread.currentThread().getStackTrace()[1].getMethodName() + "()";
        FacesContext context = FacesContext.getCurrentInstance();
        if (admin == null) {
            listaHClinica = null;
            return;
        }
        try {
            if (tipoBusqueda == 1) {
                listaHClinica = new ArrayList<>();
                //listaHClinica = admin.ejecutarQueryNativoLista("SELECT *  FROM cex_historia_clinica where hc_historia_clinica = '" + parametroBusqueda + "';", CexHistoriaClinica.class);
                listaHClinica
                        = admin.listar(CexHistoriaClinica.class, "hcHistoriaClinica", parametroBusqueda);
                //parametroBusqueda = new String();

                return;
            }
            if (tipoBusqueda == 2) {
                listaHClinica = new ArrayList<>();
                //listaHClinica = admin.ejecutarQueryNativoLista("SELECT *  FROM cex_historia_clinica where hc_cedula = '" + parametroBusqueda + "';", CexHistoriaClinica.class);
                listaHClinica
                        = admin.listar(CexHistoriaClinica.class, "hcCedula", parametroBusqueda);
                //parametroBusqueda = new String();

                return;
            }
            if (tipoBusqueda == 3) {
                apellidoPbusqueda = apellidoPbusqueda.toUpperCase().trim();
                apellidoMbusqueda = apellidoMbusqueda.toUpperCase().trim();
                pnombrebusqueda = pnombrebusqueda.toUpperCase().trim();
                snombrePbusqueda = snombrePbusqueda.toUpperCase().trim();
                if (!apellidoPbusqueda.isEmpty() || !"".equals(apellidoPbusqueda)) {
                    //listaHClinica = admin.ejecutarQueryNativoLista("SELECT * from cex_historia_clinica WHERE hc_apellido_paterno LIKE '%" + apellidoPbusqueda + "%' and hc_apellido_materno like '%" + apellidoMbusqueda + "%' and hc_primer_nombre like '%" + pnombrebusqueda + "%' and hc_segundo_nombre like '%" + snombrePbusqueda + "%'; ", CexHistoriaClinica.class);
                    listaHClinica = (List<CexHistoriaClinica>) admin.queryEJB("select a from CexHistoriaClinica a where a.hcApellidoPaterno like :var1 and a.hcApellidoMaterno like :var2 and a.hcPrimerNombre like :var3 and a.hcSegundoNombre like :var4 and a.hcEstado = :var5 ", "%" + apellidoPbusqueda + "%", "%" + apellidoMbusqueda + "%", "%" + pnombrebusqueda + "%", "%" + snombrePbusqueda + "%", 1);
                    if (listaHClinica.isEmpty() || listaHClinica.size() <= 0) {
                        listaHClinica = new ArrayList<>();
                    }
                }
            }
        } catch (Exception e) {
            log.error("{}: {} ", nombreMetodo, e);
        }

    }

    /**
     * Metodo que agrega un turno en el caso de que el turno se asigno en papel
     * yno se ingreso al sistema pero ya se hizo la consulta
     *
     *
     *
     *
     * @author David Carranza
     */
    public void agregarTurno() {
////////////////        String nombreMetodo = Thread.currentThread().getStackTrace()[1].getMethodName() + "()";
////////////////        FacesContext context = FacesContext.getCurrentInstance();
////////////////        if (admin == null) {
////////////////            listaHClinica = null;
////////////////            return;
////////////////        }
////////////////        try {
////////////////            Date fecha = new Date();
////////////////            UsuarioAdmin userT = (UsuarioAdmin) FacesContext.getCurrentInstance().getExternalContext().getSessionMap().get("user");
////////////////            if (cexMedico.getEspMedId() != null) {
////////////////                //vALIDA QUE NO SE PUEDA DAR TURNOS MAYORES A LA FECHA ACTUAL
////////////////                if (fechaBusqueda.before(fecha)) {
////////////////                    if (admin.existePorCampo(CexConsulta.class, "cexPreparacion.cexAgenda.ageFecha", fechaBusqueda, "cexPreparacion.cexAgenda.cexHistoriaClinica.hcHistoriaClinica", cexHistoria.getHcHistoriaClinica())) {
////////////////                        FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "formDatos").getClientId(), new FacesMessage(FacesMessage.SEVERITY_ERROR, "Paciente ya se encuentra agregado", "Paciente ya se encuentra agregado"));
////////////////                    } else {
////////////////                        CexAgenda objage = new CexAgenda();
////////////////                        objage.setAgeEstado(1);
////////////////                        objage.setAgeFecha(fechaBusqueda);
////////////////                        objage.setAgeIdUsuario(userT.getUser().getIdUsuario().intValue());
////////////////                        objage.setAgeNombreUsuario(userT.getUser().getAdmEmpleado().getNombreFull());
////////////////                        objage.setAgeIdInstitucion(userT.getUser().getAdmEmpleado().getAdmInstitucion().getIdInstitucion());
////////////////                        objage.setAgeNombreInstitucion(userT.getUser().getAdmEmpleado().getAdmInstitucion().getNombre());
////////////////                        objage.setAgeTipo(0);
////////////////                        objage.setCexHistoriaClinica(cexHistoria);
////////////////                        objage.setCexHorariosDia(horarioDia);
////////////////                        objage.setAgeHora(fecha);
////////////////                        HashMap<Integer, Date> objHash = asignarHoraSecuencia();
////////////////                        for (Map.Entry e : objHash.entrySet()) {
////////////////                            objage.setAgeSecuencia((Integer) e.getKey());
////////////////                            objage.setAgeHora((Date) e.getValue());
////////////////                        }
////////////////                        adminObject.crear(objage, (UsuarioAdmin) FacesContext.getCurrentInstance().getExternalContext().getSessionMap().get("user"));
////////////////                        FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "formDatos").getClientId(), new FacesMessage(FacesMessage.SEVERITY_INFO, "Turno asignado correctamente", "Turno asignado correctamente"));
////////////////                        listarTurnos();
////////////////                    }
////////////////                } else {
////////////////                    FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "formDatos").getClientId(), new FacesMessage(FacesMessage.SEVERITY_ERROR, "No se puede dar turnos en fecha mayor a la fecha actual", "No se puede dar turnos en fecha mayor a la fecha actual"));
////////////////                }
////////////////            } else {
////////////////                FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "formDatos").getClientId(), new FacesMessage(FacesMessage.SEVERITY_ERROR, "Seleccione medico", "Seleccione medico"));
////////////////            }
////////////////        } catch (Exception e) {
////////////////            log.error("{}: {} ", nombreMetodo, e);
////////////////        }

    }

    /**
     * Metodo generico que crea un detalle de la agenda selecionada
     *
     * @author David Carranza
     * @return
     */
    public HashMap<Integer, Date> asignarHoraSecuencia() {
        HashMap<Integer, Date> mp = new HashMap<>();
//////////////        try {
//////////////            List<CexAgenda> listaDescendente = adminObject.listarOrdenada(CexAgenda.class, "cexHorariosDia", horarioDia, "ageFecha", fechaBusqueda, "ageSecuencia", false);
//////////////            CexAgenda objAgenda = listaDescendente.get(0);
//////////////
//////////////            BigDecimal numConsultas = new BigDecimal(horarioDia.getHodNumConsultas());
//////////////            Calendar c3 = Calendar.getInstance();
//////////////            Boolean HorAm = false;
//////////////            Boolean HorPm = false;
//////////////            Boolean nuevaHora = true;
//////////////            Integer secuencia;
//////////////
//////////////            //Transformas las horas en milisegundos
//////////////            if (horarioDia.getHodHoraInicioAm() != null) {
//////////////                horaInicioAm.setTime(horarioDia.getHodHoraInicioAm());
//////////////            } else {
//////////////                horaInicioAm.setTimeInMillis(0);
//////////////            }
//////////////            if (horarioDia.getHodHoraFinAm() != null) {
//////////////                horaFinAm.setTime(horarioDia.getHodHoraFinAm());
//////////////            } else {
//////////////                horaFinAm.setTimeInMillis(0);
//////////////            }
//////////////            if (horarioDia.getHodHoraInicioPm() != null) {
//////////////                horaInicioPm.setTime(horarioDia.getHodHoraInicioPm());
//////////////            } else {
//////////////                horaInicioPm.setTimeInMillis(0);
//////////////            }
//////////////            if (horarioDia.getHodHoraFinPm() != null) {
//////////////                horaFinPm.setTime(horarioDia.getHodHoraFinPm());
//////////////            } else {
//////////////                horaFinPm.setTimeInMillis(0);
//////////////            }
//////////////
//////////////            long iniAm = horaInicioAm.getTimeInMillis();
//////////////            long finAm = horaFinAm.getTimeInMillis();
//////////////            long iniPm = horaInicioPm.getTimeInMillis();
//////////////            long finPm = horaFinPm.getTimeInMillis();
//////////////            //calcular total de minitos al dia asignado al medico
//////////////            long totHoras = ((finAm - iniAm) + (finPm - iniPm));
//////////////
//////////////            // calcular la diferencia en milisengundos
//////////////            //long diff = milis2 - milis1;
//////////////            // calcular la diferencia en segundos
//////////////            //long diffSeconds = diff / 1000;
//////////////            // calcular la diferencia en minutos
//////////////            long diffMinutes = totHoras / (60 * 1000);
//////////////
//////////////            // calcular la diferencia en horas
//////////////            //long diffHours = diff / (60 * 60 * 1000);
//////////////            // calcular la diferencia en dias
//////////////            //long diffDays = diff / (24 * 60 * 60 * 1000);
//////////////            BigDecimal rangoMuinutos = (new BigDecimal(diffMinutes).divide(numConsultas)).setScale(0, RoundingMode.UP);
//////////////
//////////////            if (objAgenda.getAgeSecuencia() == 0) {
//////////////                //Sacar la hora minima verificando la hora de inicio am o pm
//////////////                if (horarioDia.getHodHoraInicioAm() != null) {
//////////////                    HorAm = true;
//////////////                    c3.setTime(horarioDia.getHodHoraInicioAm());
//////////////                } else {
//////////////                    if (horarioDia.getHodHoraFinAm() != null) {
//////////////                        HorAm = true;
//////////////                        c3.setTime(horarioDia.getHodHoraFinAm());
//////////////                    } else {
//////////////                        if (horarioDia.getHodHoraInicioPm() != null) {
//////////////                            HorPm = true;
//////////////                            c3.setTime(horarioDia.getHodHoraInicioPm());
//////////////                        } else {
//////////////                            HorPm = true;
//////////////                            c3.setTime(horarioDia.getHodHoraFinPm());
//////////////                        }
//////////////                    }
//////////////
//////////////                }
//////////////                secuencia = 1;
//////////////            } else {
//////////////                //calcular total de minitos al dia asignado al medico
//////////////                c3.setTime(objAgenda.getAgeHora());
//////////////                if (HorAm) {
//////////////                    if (nuevaHora == true) {
//////////////                        if (objAgenda.getAgeHora().after(horarioDia.getHodHoraFinAm()) || objAgenda.getAgeHora().equals((horarioDia.getHodHoraFinAm()))) {
//////////////                            if (horarioDia.getHodHoraInicioPm() != null) {
//////////////                                c3.setTime(horarioDia.getHodHoraInicioPm());
//////////////                            } else {
//////////////                                c3.setTime(horarioDia.getHodHoraFinAm());
//////////////                            }
//////////////                            nuevaHora = false;
//////////////                            agenda.setAgeHora(c3.getTime());
//////////////                        }
//////////////
//////////////                    }
//////////////
//////////////                }
//////////////                secuencia = objAgenda.getAgeSecuencia() + 1;
//////////////                c3.add(Calendar.MINUTE, rangoMuinutos.intValue());
//////////////
//////////////            }
//////////////
//////////////            mp.put(secuencia, c3.getTime());
//////////////        } catch (Exception e) {
//////////////            log.error("{}: {} ", "asignarHoraSecuencia", e);
//////////////        }
        return mp;
    }

    @Override
    public DataModel<CexConsulta> getDataModel() {
        return null;
    }

//    public HcEspecialidad getSubEspecialidad() {
//        return subEspecialidad;
//    }
//
//    public void setSubEspecialidad(HcEspecialidad subEspecialidad) {
//        this.subEspecialidad = subEspecialidad;
//    }
    public AdmUsuario getUsuario() {
        return usuario;
    }

    public void setUsuario(AdmUsuario usuario) {
        this.usuario = usuario;
    }

    public CexRevisionOrganos getRevisionOrganos() {
        return revisionOrganos;
    }

    public void setRevisionOrganos(CexRevisionOrganos revisionOrganos) {
        this.revisionOrganos = revisionOrganos;
    }

    public CexPreparacion getPreparacion() {
        return preparacion;
    }

    public void setPreparacion(CexPreparacion preparacion) {
        this.preparacion = preparacion;
    }

    public CexAgenda getAgenda() {
        return agenda;
    }

    public void setAgenda(CexAgenda agenda) {
        this.agenda = agenda;
    }

    public CexExamenFisico getExamenFisico() {
        return examenFisico;
    }

    public void setExamenFisico(CexExamenFisico examenFisico) {
        this.examenFisico = examenFisico;
    }

    @Override
    protected ResourceBundle getProperties() {
        return ResourceBundle.getBundle("aplicacion");
    }

    public CexDiagnosticoConsulta getDiagnostico1() {
        return diagnostico1;
    }

    public void setDiagnostico1(CexDiagnosticoConsulta diagnostico1) {
        this.diagnostico1 = diagnostico1;
    }

    public List<CexDiagnosticoConsulta> getListaDiagnostico() {
        return listaDiagnostico;
    }

    public void setListaDiagnostico(List<CexDiagnosticoConsulta> listaDiagnostico) {
        this.listaDiagnostico = listaDiagnostico;
    }

    public String getBusquedaDiagnostico() {
        return busquedaDiagnostico;
    }

    public void setBusquedaDiagnostico(String busquedaDiagnostico) {
        this.busquedaDiagnostico = busquedaDiagnostico;
    }

    public int getTipoBusquedaDiagnostico() {
        return tipoBusquedaDiagnostico;
    }

    public void setTipoBusquedaDiagnostico(int tipoBusquedaDiagnostico) {
        this.tipoBusquedaDiagnostico = tipoBusquedaDiagnostico;
    }

    public List<CexDiagnostico> getListadiagnosticoPopup() {
        return listadiagnosticoPopup;
    }

    public void setListadiagnosticoPopup(List<CexDiagnostico> listadiagnosticoPopup) {
        this.listadiagnosticoPopup = listadiagnosticoPopup;
    }

    public List<CexHorariosDia> getListaDetalle() {
        return listaDetalle;
    }

    public void setListaDetalle(List<CexHorariosDia> listaDetalle) {
        this.listaDetalle = listaDetalle;
    }

    public Date getFechaBusqueda() {
        return fechaBusqueda;
    }

    public void setFechaBusqueda(Date fechaBusqueda) {
        this.fechaBusqueda = fechaBusqueda;
    }

    public Date getFechaAgenda() {
        return fechaAgenda;
    }

    public void setFechaAgenda(Date fechaAgenda) {
        this.fechaAgenda = fechaAgenda;
    }

    public CexEspecialidad getSubEspecialidad() {
        return subEspecialidad;
    }

    public void setSubEspecialidad(CexEspecialidad subEspecialidad) {
        this.subEspecialidad = subEspecialidad;
    }

    public CexEspecialidad getEspecialidad() {
        return especialidad;
    }

    public void setEspecialidad(CexEspecialidad especialidad) {
        this.especialidad = especialidad;
    }

    public CexHorariosDia getHorarioDia() {
        return horarioDia;
    }

    public void setHorarioDia(CexHorariosDia horarioDia) {
        this.horarioDia = horarioDia;
    }

    public String getClave() {
        return clave;
    }

    public void setClave(String clave) {
        this.clave = clave;
    }

    public Integer getNumredaca() {
        return numredaca;
    }

    public void setNumredaca(Integer numredaca) {
        this.numredaca = numredaca;
    }

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public String getCedula() {
        return cedula;
    }

    public void setCedula(String cedula) {
        this.cedula = cedula;
    }

    public CexGrupoAtencion getGrupoAtencion() {
        return grupoAtencion;
    }

    public void setGrupoAtencion(CexGrupoAtencion grupoAtencion) {
        this.grupoAtencion = grupoAtencion;
    }

    public CexEspecialidadMedico getCexMedico() {
        return cexMedico;
    }

    public void setCexMedico(CexEspecialidadMedico cexMedico) {
        this.cexMedico = cexMedico;
    }

    public Date getFechaInicio() {
        return fechaInicio;
    }

    public void setFechaInicio(Date fechaInicio) {
        this.fechaInicio = fechaInicio;
    }

    public Date getFechaFin() {
        return fechaFin;
    }

    public void setFechaFin(Date fechaFin) {
        this.fechaFin = fechaFin;
    }

    public List<CexHistoriaClinica> getListaHClinica() {
        return listaHClinica;
    }

    public void setListaHClinica(List<CexHistoriaClinica> listaHClinica) {
        this.listaHClinica = listaHClinica;
    }

    public String getApellidoPbusqueda() {
        return apellidoPbusqueda;
    }

    public void setApellidoPbusqueda(String apellidoPbusqueda) {
        this.apellidoPbusqueda = apellidoPbusqueda;
    }

    public String getApellidoMbusqueda() {
        return apellidoMbusqueda;
    }

    public void setApellidoMbusqueda(String apellidoMbusqueda) {
        this.apellidoMbusqueda = apellidoMbusqueda;
    }

    public String getPnombrebusqueda() {
        return pnombrebusqueda;
    }

    public void setPnombrebusqueda(String pnombrebusqueda) {
        this.pnombrebusqueda = pnombrebusqueda;
    }

    public String getSnombrePbusqueda() {
        return snombrePbusqueda;
    }

    public void setSnombrePbusqueda(String snombrePbusqueda) {
        this.snombrePbusqueda = snombrePbusqueda;
    }

    public CexHistoriaClinica getCexHistoria() {
        return cexHistoria;
    }

    public void setCexHistoria(CexHistoriaClinica cexHistoria) {
        this.cexHistoria = cexHistoria;
    }

    public Integer getTipoBusqueda() {
        return tipoBusqueda;
    }

    public void setTipoBusqueda(Integer tipoBusqueda) {
        this.tipoBusqueda = tipoBusqueda;
    }

    public String getParametroBusqueda() {
        return parametroBusqueda;
    }

    public void setParametroBusqueda(String parametroBusqueda) {
        this.parametroBusqueda = parametroBusqueda;
    }

    public boolean isIsPrevencion() {
        return isPrevencion;
    }

    public void setIsPrevencion(boolean isPrevencion) {
        this.isPrevencion = isPrevencion;
    }
}
